package com.spring.bean.classloader;

/**
 * JVM提供了3种类加载器：BootstrapClassLoader、ExtClassLoader、AppClassLoader分别加载Java核心类库、扩展类库以及应用的类路径(CLASSPATH)下的类库。
 * JVM通过双亲委派模型进行类的加载，我们也可以通过继承java.lang.classloader实现自己的类加载器。
 *
 * 何为双亲委派模型？当一个类加载器收到类加载任务时，会先交给自己的父加载器去完成，因此最终加载任务都会传递到最顶层的BootstrapClassLoader，只有当父加载器无法完成加载任务时，才会尝试自己来加载。
 *
 * 采用双亲委派模型的一个好处是保证使用不同类加载器最终得到的都是同一个对象，
 * 这样就可以保证Java 核心库的类型安全，
 * 比如，加载位于rt.jar包中的java.lang.Object类，不管是哪个加载器加载这个类，最终都是委托给顶层的BootstrapClassLoader来加载的，
 * 这样就可以保证任何的类加载器最终得到的都是同样一个Object对象。查看ClassLoader的源码，对双亲委派模型会有更直观的认识：
 *
 * protected Class<?> loadClass(String name, boolean resolve) {
 *     synchronized (getClassLoadingLock(name)) {
 *     // 首先，检查该类是否已经被加载，如果从JVM缓存中找到该类，则直接返回
 *     Class<?> c = findLoadedClass(name);
 *     if (c == null) {
 *         try {
 *             // 遵循双亲委派的模型，首先会通过递归从父加载器开始找，
 *             // 直到父类加载器是BootstrapClassLoader为止
 *             if (parent != null) {
 *                 c = parent.loadClass(name, false);
 *             } else {
 *                 c = findBootstrapClassOrNull(name);
 *             }
 *         } catch (ClassNotFoundException e) {}
 *         if (c == null) {
 *             // 如果还找不到，尝试通过findClass方法去寻找
 *             // findClass是留给开发者自己实现的，也就是说
 *             // 自定义类加载器时，重写此方法即可
 *            c = findClass(name);
 *         }
 *     }
 *     if (resolve) {
 *         resolveClass(c);
 *     }
 *     return c;
 *     }
 * }
 *
 * 但双亲委派模型并不能解决所有的类加载器问题，
 * 比如，Java 提供了很多服务提供者接口(Service Provider Interface，SPI)，允许第三方为这些接口提供实现。
 * 常见的 SPI 有 JDBC、JNDI、JAXP 等，这些SPI的接口由核心类库提供，却由第三方实现，
 * 这样就存在一个问题：SPI 的接口是 Java 核心库的一部分，是由BootstrapClassLoader加载的；SPI实现的Java类一般是由AppClassLoader来加载的。
 * BootstrapClassLoader是无法找到 SPI 的实现类的，因为它只加载Java的核心库。它也不能代理给AppClassLoader，因为它是最顶层的类加载器。也就是说，双亲委派模型并不能解决这个问题。
 *
 * 线程上下文类加载器(ContextClassLoader)正好解决了这个问题。
 * 从名称上看，可能会误解为它是一种新的类加载器，实际上，它仅仅是Thread类的一个变量而已，可以通过setContextClassLoader(ClassLoader cl)和getContextClassLoader()来设置和获取该对象。
 * 如果不做任何的设置，Java应用的线程的上下文类加载器默认就是AppClassLoader。在核心类库使用SPI接口时，传递的类加载器使用线程上下文类加载器，就可以成功的加载到SPI实现的类。
 * 线程上下文类加载器在很多SPI的实现中都会用到。但在JDBC中，你可能会看到一种更直接的实现方式，比如，JDBC驱动管理java.sql.Driver中的loadInitialDrivers()方法中，你可以直接看到JDK是如何加载驱动的：
 *
 * for (String aDriver : driversList) {
 *     try {
 *         // 直接使用AppClassLoader
 *         Class.forName(aDriver, true, ClassLoader.getSystemClassLoader());
 *     } catch (Exception ex) {
 *         println("DriverManager.Initialize: load failed: " + ex);
 *     }
 * }
 * 其实讲解线程上下文类加载器，最主要是让大家在看到Thread.currentThread().getClassLoader()和Thread.currentThread().getContextClassLoader()时不会一脸懵逼，
 * 这两者除了在许多底层框架中取得的ClassLoader可能会有所不同外，其他大多数业务场景下都是一样的，大家只要知道它是为了解决什么问题而存在的即可。
 *
 * 类加载器除了加载class外，还有一个非常重要功能，就是加载资源，它可以从jar包中读取任何资源文件，比如，ClassLoader.getResources(String name)方法就是用于读取jar包中的资源文件，其代码如下：
 *
 * public Enumeration<URL> getResources(String name) throws IOException {
 *     Enumeration<URL>[] tmp = (Enumeration<URL>[]) new Enumeration<?>[2];
 *     if (parent != null) {
 *         tmp[0] = parent.getResources(name);
 *     } else {
 *         tmp[0] = getBootstrapResources(name);
 *     }
 *     tmp[1] = findResources(name);
 *     return new CompoundEnumeration<>(tmp);
 * }
 * 是不是觉得有点眼熟，不错，它的逻辑其实跟类加载的逻辑是一样的，首先判断父类加载器是否为空，不为空则委托父类加载器执行资源查找任务，直到BootstrapClassLoader，最后才轮到自己查找。
 * 而不同的类加载器负责扫描不同路径下的jar包，就如同加载class一样，最后会扫描所有的jar包，找到符合条件的资源文件。
 *
 * 类加载器的findResources(name)方法会遍历其负责加载的所有jar包，找到jar包中名称为name的资源文件，这里的资源可以是任何文件，甚至是.class文件，比如下面的示例，用于查找Array.class文件：
 *
 * // 寻找Array.class文件
 * public static void main(String[] args) throws Exception{
 *     // Array.class的完整路径
 *     String name = "java/sql/Array.class";
 *     Enumeration<URL> urls = Thread.currentThread().getContextClassLoader().getResources(name);
 *     while (urls.hasMoreElements()) {
 *         URL url = urls.nextElement();
 *         System.out.println(url.toString());
 *     }
 * }
 * 运行后可以得到如下结果：
 *
 * $JAVA_HOME/jre/lib/rt.jar!/java/sql/Array.class
 * 根据资源文件的URL，可以构造相应的文件来读取资源内容。
 *
 * 看到这里，你可能会感到挺奇怪的，你不是要详解SpringFactoriesLoader吗？上来讲了一堆ClassLoader是几个意思？看下它的源码你就知道了：
 *
 * public static final String FACTORIES_RESOURCE_LOCATION = "META-INF/spring.factories";
 * // spring.factories文件的格式为：key=value1,value2,value3
 * // 从所有的jar包中找到META-INF/spring.factories文件
 * // 然后从文件中解析出key=factoryClass类名称的所有value值
 * public static List<String> loadFactoryNames(Class<?> factoryClass, ClassLoader classLoader) {
 *     String factoryClassName = factoryClass.getName();
 *     // 取得资源文件的URL
 *     Enumeration<URL> urls = (classLoader != null ? classLoader.getResources(FACTORIES_RESOURCE_LOCATION) : ClassLoader.getSystemResources(FACTORIES_RESOURCE_LOCATION));
 *     List<String> result = new ArrayList<String>();
 *     // 遍历所有的URL
 *     while (urls.hasMoreElements()) {
 *         URL url = urls.nextElement();
 *         // 根据资源文件URL解析properties文件
 *         Properties properties = PropertiesLoaderUtils.loadProperties(new UrlResource(url));
 *         String factoryClassNames = properties.getProperty(factoryClassName);
 *         // 组装数据，并返回
 *         result.addAll(Arrays.asList(StringUtils.commaDelimitedListToStringArray(factoryClassNames)));
 *     }
 *     return result;
 * }
 * 有了前面关于ClassLoader的知识，再来理解这段代码，是不是感觉豁然开朗：从CLASSPATH下的每个Jar包中搜寻所有META-INF/spring.factories配置文件，然后将解析properties文件，找到指定名称的配置后返回。需要注意的是，其实这里不仅仅是会去ClassPath路径下查找，会扫描所有路径下的Jar包，只不过这个文件只会在Classpath下的jar包中。来简单看下spring.factories文件的内容吧：
 *
 * // 来自 org.springframework.boot.autoconfigure下的META-INF/spring.factories
 * // EnableAutoConfiguration后文会讲到，它用于开启Spring Boot自动配置功能
 * org.springframework.boot.autoconfigure.EnableAutoConfiguration=\
 * org.springframework.boot.autoconfigure.admin.SpringApplicationAdminJmxAutoConfiguration,\
 * org.springframework.boot.autoconfigure.aop.AopAutoConfiguration,\
 * org.springframework.boot.autoconfigure.amqp.RabbitAutoConfiguration\
 * 执行loadFactoryNames(EnableAutoConfiguration.class, classLoader)后，得到对应的一组@Configuration类， 我们就可以通过反射实例化这些类然后注入到IOC容器中，最后容器里就有了一系列标注了@Configuration的JavaConfig形式的配置类。
 *
 * 这就是SpringFactoriesLoader，它本质上属于Spring框架私有的一种扩展方案，类似于SPI，Spring Boot在Spring基础上的很多核心功能都是基于此，希望大家可以理解。
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 * */

public class MyClassLoader {
}
